package com.bdcom.autotest.interaction.socket;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.bdcom.autotest.util.Prop;


public class DataUtil {
	
	private static Logger log = LoggerFactory.getLogger(DataUtil.class);
	
	
	
	/**
	 * HOST发送测试设备当前测试模式命gou令
	 * 
	 * @param tmode 当前测试模式： 1--机箱测试模式  2-- 主控测试模式  3--线卡测试模式
 	 * @param chassisType      8510C:0X1161       8506C:0X1162
	 * @param msutype      1:MSU-I       2:MSU-II
	 * @param lstype    对于机箱和主控测试，应当选用16TS线卡，所以应当选3，对于线卡测试，可由SN扫描获得的线卡类型确定。所有的线卡类型应当都是一样的 	 
			LS85C_16TS_CARD ：      0x03
			LS85C_48GS_CARD  ：     0x04
			LS85C_48GT_CARD ：      0x05
			LS85C_4QS_CARD ：      0x06
			LS85C_24GS_8TS_CARD ：      0x07
			LS85C_24GS_24GT_CARD：		0x08
	 * @param lsnum		
			线卡的数量，对于机箱测试模式和主控测试模式来说，要求线卡是满配的，此字段忽略，
			对于线卡模式来说，要求指定线卡的数量，且必须是偶数块，从SLOT 1开始插。测试程序会根据数量进行检查
	 * @return
	 */
	public static byte[] createTestModeData( byte tmode ,  String chassisType , byte msutype, byte lstype  , byte lsnum ) {
		
		byte[] byteArray = null;
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(baos); 
		try {
			out.write( null );
			
			byteArray = baos.toByteArray();
			out.close();
			baos.close();
		} catch ( Exception e ) {
			log.error( "" , e);
		}
		
		return byteArray;
	}
	
	
	
	public static byte[] arrayJoin(byte[] a, byte[] b) {
		byte[] arr = new byte[a.length + b.length];// 开辟新数组长度为两数组之和
		for (int i = 0; i < a.length; i++) {// 拷贝a数组到目标数组arr
			arr[i] = a[i];
		}
		for (int j = 0; j < b.length; j++) {// 拷贝b数组到目标数组arr
			arr[a.length + j] = b[j];
		}
		return arr;
	}
	
	public static int bytes2Int(byte[] bytes) {
		int result = 0;
		//将每个byte依次搬运到int相应的位置
		result = bytes[0] & 0xff;
		result = result << 8 | bytes[1] & 0xff;
		return result;
	}
	
	public static byte[] int2Bytes(int num) {
		byte[] bytes = new byte[4];
		//通过移位运算，截取低8位的方式，将int保存到byte数组
		bytes[0] = (byte)(num >>> 24);
		bytes[1] = (byte)(num >>> 16);
		bytes[2] = (byte)(num >>> 8);
		bytes[3] = (byte)num;
		return bytes;
	}
	

	public static String byte2Binary(byte tByte) {
		String tString = Integer.toBinaryString((tByte & 0xFF) + 0x100).substring(1);
		return tString;
	}

	public static byte[] byteMerger(byte[] bt1, byte[] bt2){  
        byte[] bt3 = new byte[bt1.length+bt2.length];  
        System.arraycopy(bt1, 0, bt3, 0, bt1.length);  
        System.arraycopy(bt2, 0, bt3, bt1.length, bt2.length);  
        return bt3;  
    } 
	
	public static String[] deleteArrayNull(String string[]) {
        String strArr[] = string;
        ArrayList<String> strList = new ArrayList<String>();
        for (int i = 0; i < strArr.length; i++) {
            strList.add(strArr[i]);
        }
        while (strList.remove(null));
        while (strList.remove(""));
        String strArrLast[] = strList.toArray(new String[strList.size()]);
        return strArrLast;
    }
	
	public static String getDevType(String sn) {
		String deviceType = null;
		int size = sn.length();
        long frontCode = Long.valueOf(sn.substring(0,size-5));
        int otherCode = Integer.valueOf(sn.substring(size-5,size));
        JSONArray arr  = Prop.deviceTypeArr;
		for (Object obj : arr) {
			JSONObject tmpObject = (JSONObject) obj;
			
			try {
				long frontCode1 = tmpObject.getLong("frontCode1");
				long frontCode2 = tmpObject.getInteger("frontCode2");
				int startCode = tmpObject.getInteger("startCode");
				int endCode = tmpObject.getInteger("endCode");
				if(frontCode<frontCode1||frontCode>frontCode2){
					continue;
				}
				if (otherCode >= startCode && startCode <= endCode) {
					deviceType = tmpObject.getString("deviceType");
					break;
				}
			} catch (JSONException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return deviceType;
    }
}
